﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.IO;
using System.Windows.Forms;

namespace Cataloger
{
    /// <summary>
    /// Klasa wspomagająca funkcję Asystenta Wyszukiwania
    /// </summary>
    public class AsystenWysz
    {
		#region Fields (2) 

        HashSet<ArchiwumEntry> plikiWArchiwach = new HashSet<ArchiwumEntry>();
        HashSet<ObiektDyskowy> plikiZnalezione = new HashSet<ObiektDyskowy>();

		#endregion Fields 

		#region Constructors (1) 

        public AsystenWysz()
        {
            
        }

		#endregion Constructors 

		#region Properties (2) 

        public HashSet<ArchiwumEntry> PlikiWArchiwach
        {
            get { return plikiWArchiwach; }
        }

        public HashSet<ObiektDyskowy> PlikiZnalezione
        {
            get { return plikiZnalezione; }
        }

		#endregion Properties 

		#region Methods (18) 

		// Public Methods (16) 

        public void SzukajDataDostDo(DateTime dataDostDo)
        {
            HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
            HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
            foreach (Plik p in plikiZnalezione)
            {
                if (p.DataDost <= dataDostDo)
                {
                    plikiZteraz.Add(p);
                }
            }
            plikiZnalezione = plikiZteraz;
            plikiWArchiwach = plikiZterazA;
        }

        public void SzukajDataDostOd(DateTime dataDostOd)
        {
            HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
            HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
            foreach (Plik p in plikiZnalezione)
            {
                if (p.DataDost >= dataDostOd)
                {
                    plikiZteraz.Add(p);
                }
            }
            plikiZnalezione = plikiZteraz;
            plikiWArchiwach = plikiZterazA;
        }

        public void SzukajDataModDo(DateTime dataModDo)
        {
            HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
            HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
            foreach (Plik p in plikiZnalezione)
            {
                if (p.DataMod <= dataModDo)
                {
                    plikiZteraz.Add(p);
                }
            }
            foreach (ArchiwumEntry p in plikiWArchiwach)
            {
                
                if (p.DataModyfikacj<=dataModDo)
                {
                    plikiZterazA.Add(p);
                }
                
            }

            plikiZnalezione = plikiZteraz;
            plikiWArchiwach = plikiZterazA;
        }

        public void SzukajDataModOd(DateTime dataModOd)
        {
            HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
            HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
            foreach (Plik p in plikiZnalezione)
            {
                if (p.DataMod >= dataModOd)
                {
                    plikiZteraz.Add(p);
                }
            }
            foreach (ArchiwumEntry p in plikiWArchiwach)
            {

                if (p.DataModyfikacj >= dataModOd)
                {
                    plikiZterazA.Add(p);
                }

            }

            plikiZnalezione = plikiZteraz;
            plikiWArchiwach = plikiZterazA;
        }

        public void SzukajDataUtwDo(DateTime dataUtwDo)
        {
            HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
            HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
            foreach (Plik p in plikiZnalezione)
            {
                if (p.DataUtw <= dataUtwDo)
                {
                    plikiZteraz.Add(p);
                }
            }
            plikiZnalezione = plikiZteraz;
            plikiWArchiwach = plikiZterazA;
        }

        public void SzukajDataUtwOd(DateTime dataUtwOd)
        {
            HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
            HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
            foreach (Plik p in plikiZnalezione)
            {
                if (p.DataUtw >= dataUtwOd)
                {
                    plikiZteraz.Add(p);
                }
            }
            plikiZnalezione = plikiZteraz;
            plikiWArchiwach = plikiZterazA;
        }

        public void SzukajKataegoria(Kategoria kat)
        {
            HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
            HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
            foreach (Plik p in plikiZnalezione)
            {
                if (p.Kategoria==kat)
                {
                    plikiZteraz.Add(p);
                }
            }
            plikiZnalezione = plikiZteraz;
            plikiWArchiwach = plikiZterazA;
        }

        public void SzukajLokalizacja(List<Folder>Foldery)
        {
            plikiWArchiwach.Clear();
            plikiZnalezione.Clear();
            foreach (Folder f in Foldery)
            {
                szukajRek(f);
                szukajRekArch(f);
            }
        
        }

        public void SzukajNazwa(string nazwa,bool regex, bool caseSens)
        {
            if (!regex)
            {
                if (!caseSens)
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                    foreach (Plik p in plikiZnalezione)
                    {
                        if (Path.GetFileNameWithoutExtension(p.Nazwa).ToLower().Contains(nazwa.ToLower()))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    foreach (ArchiwumEntry p in plikiWArchiwach)
                    {
                        if (Path.GetFileNameWithoutExtension(p.NazwaBezSciezki).ToLower().Contains(nazwa.ToLower()))
                        {
                            plikiZterazA.Add(p);
                        }
                    }

                    plikiZnalezione = plikiZteraz;
                    plikiWArchiwach = plikiZterazA;
                }
                else
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                    foreach (Plik p in plikiZnalezione)
                    {
                        if (Path.GetFileNameWithoutExtension(p.Nazwa).Contains(nazwa))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    foreach (ArchiwumEntry p in plikiWArchiwach)
                    {
                        if (Path.GetFileNameWithoutExtension(p.NazwaBezSciezki).Contains(nazwa))
                        {
                            plikiZterazA.Add(p);
                        }
                    }
                    plikiWArchiwach = plikiZterazA;
                    plikiZnalezione = plikiZteraz;
                }
            }
            else
            {
                if (!caseSens)
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                    foreach (Plik p in plikiZnalezione)
                    {
                        if (Regex.IsMatch(Path.GetFileNameWithoutExtension(p.Nazwa).ToLower(),nazwa.ToLower(),RegexOptions.IgnoreCase))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    foreach (ArchiwumEntry p in plikiWArchiwach)
                    {
                        if (Regex.IsMatch(Path.GetFileNameWithoutExtension(p.NazwaBezSciezki).ToLower(), nazwa.ToLower(), RegexOptions.IgnoreCase))
                        {
                            plikiZterazA.Add(p);
                        }
                    }
                    plikiWArchiwach = plikiZterazA;
                    plikiZnalezione = plikiZteraz;
                }
                else
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                    foreach (Plik p in plikiZnalezione)
                    {
                        if (Regex.IsMatch(Path.GetFileNameWithoutExtension(p.Nazwa), nazwa))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    foreach (ArchiwumEntry p in plikiWArchiwach)
                    {
                        if (Regex.IsMatch(Path.GetFileNameWithoutExtension(p.NazwaBezSciezki), nazwa))
                        {
                            plikiZterazA.Add(p);
                        }
                    }
                    plikiWArchiwach = plikiZterazA;
                    plikiZnalezione = plikiZteraz;
                }
            }
        }

        public void SzukajOpis(string opis, bool regex, bool caseSens)
        {
            if (!regex)
            {
                if (!caseSens)
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                     foreach (Plik p in plikiZnalezione)
                    {
                        if (p.Opis.ToLower().Contains(opis.ToLower()))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    plikiZnalezione = plikiZteraz;
                    plikiWArchiwach = plikiZterazA;
                }
                else
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                    foreach (Plik p in plikiZnalezione)
                    {
                        if (p.Opis.Contains(opis))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    plikiZnalezione = plikiZteraz;
                    plikiWArchiwach = plikiZterazA;
                }
            }
            else
            {
                if (!caseSens)
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                     foreach (Plik p in plikiZnalezione)
                    {
                        if (Regex.IsMatch(p.Opis.ToLower(), opis.ToLower(), RegexOptions.IgnoreCase))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    plikiZnalezione = plikiZteraz;
                    plikiWArchiwach = plikiZterazA;
                }
                else
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                    foreach (Plik p in plikiZnalezione)
                    {
                        if (Regex.IsMatch(p.Opis, opis))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    plikiZnalezione = plikiZteraz;
                    plikiWArchiwach = plikiZterazA;
                }
            }

        }

        public void SzukajRozmiarDo(long rozmiarDo)
        {
            HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
            HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
            foreach (Plik p in plikiZnalezione)
            {
                if (p.Rozmiar <= rozmiarDo)
                {
                    plikiZteraz.Add(p);
                }
            }
            foreach (ArchiwumEntry p in plikiWArchiwach)
            {

                if (p.RozmiarPrzed <= rozmiarDo)
                {
                    plikiZterazA.Add(p);
                }

            }

            plikiZnalezione = plikiZteraz;
            plikiWArchiwach = plikiZterazA;
        }

        public void SzukajRozmiarOd(long rozmiarOd)
        {
            HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
            HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
            foreach (Plik p in plikiZnalezione)
            {
                if (p.Rozmiar>=rozmiarOd)
                {
                    plikiZteraz.Add(p);
                }
            }
            foreach (ArchiwumEntry p in plikiWArchiwach)
            {

                if (p.RozmiarPrzed >= rozmiarOd)
                {
                    plikiZterazA.Add(p);
                }

            }

            plikiZnalezione = plikiZteraz;
            plikiWArchiwach = plikiZterazA;
        }

        public void SzukajRozsz(string rozszerzenie, bool regex, bool caseSens)
        {
            if (!regex)
            {
                if (!caseSens)
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                    foreach (Plik p in plikiZnalezione)
                    {
                        if (p.Rozszerzenie.ToLower().Contains(rozszerzenie.ToLower()))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    foreach (ArchiwumEntry p in plikiWArchiwach)
                    {
                        if (Path.GetExtension(p.NazwaBezSciezki).ToLower().Contains(rozszerzenie.ToLower()))
                        {
                            plikiZterazA.Add(p);
                        }
                    }

                    plikiZnalezione = plikiZteraz;
                    plikiWArchiwach = plikiZterazA;
                }
                else
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                    foreach (Plik p in plikiZnalezione)
                    {
                        if (p.Rozszerzenie.Contains(rozszerzenie))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    foreach (ArchiwumEntry p in plikiWArchiwach)
                    {
                        if (Path.GetExtension(p.NazwaBezSciezki).Contains(rozszerzenie))
                        {
                            plikiZterazA.Add(p);
                        }
                    }

                    plikiZnalezione = plikiZteraz;
                    plikiWArchiwach = plikiZterazA;
                }
            }
            else
            {
                if (!caseSens)
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                    foreach (Plik p in plikiZnalezione)
                    {
                        if (Regex.IsMatch(p.Rozszerzenie.ToLower(), rozszerzenie.ToLower(), RegexOptions.IgnoreCase))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    foreach (ArchiwumEntry p in plikiWArchiwach)
                    {
                        if (Regex.IsMatch(Path.GetExtension(p.NazwaBezSciezki).ToLower(), rozszerzenie.ToLower(), RegexOptions.IgnoreCase))
                        {
                            plikiZterazA.Add(p);
                        }
                    }
                    plikiWArchiwach = plikiZterazA;
                    plikiZnalezione = plikiZteraz;
                }
                else
                {
                    HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
                    HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
                    foreach (Plik p in plikiZnalezione)
                    {
                        if (Regex.IsMatch(p.Rozszerzenie, rozszerzenie))
                        {
                            plikiZteraz.Add(p);
                        }
                    }
                    foreach (ArchiwumEntry p in plikiWArchiwach)
                    {
                        if (Regex.IsMatch(Path.GetExtension(p.NazwaBezSciezki), rozszerzenie))
                        {
                            plikiZterazA.Add(p);
                        }
                    }
                    plikiWArchiwach = plikiZterazA;
                    plikiZnalezione = plikiZteraz;
                }
            }
        }

        public void SzukajTypPliku(TypPliku typ)
        {
            HashSet<ObiektDyskowy> plikiZteraz = new HashSet<ObiektDyskowy>();
            HashSet<ArchiwumEntry> plikiZterazA = new HashSet<ArchiwumEntry>();
            foreach (Plik p in plikiZnalezione)
            {
                foreach (string slowo in typ.SlowaW)
                {
                    if (p.Nazwa.ToLower().Trim().Contains(slowo))
                    {
                        plikiZteraz.Add(p);
                    }
                }
                    
                
            }
            foreach (ArchiwumEntry p in plikiWArchiwach)
            {
                foreach (string slowo in typ.SlowaW)
                {
                    if (p.NazwaBezSciezki.ToLower().Trim().Contains(slowo))
                    {
                        plikiZterazA.Add(p);
                    }
                }
            }

            plikiZnalezione = plikiZteraz;
            plikiWArchiwach = plikiZterazA;
        }

        public void SzukajWszystkieArchiwa()
        {
            foreach (Katalog kat in Globalne.WczytaneKatalogi)
            {
                foreach (Nosnik nos in kat.Nosniki)
                {
                    szukajRekArch(nos.Root);
                }
            }
        }

        public void SzukajWszystkiePliki()
        {
            foreach (Katalog kat in Globalne.WczytaneKatalogi)
            {
                foreach (Nosnik nos in kat.Nosniki)
                {
                    szukajRek(nos.Root);
                }
            }
        }
		// Private Methods (2) 

        private void szukajRek(Folder fold)
        {
            foreach (Plik p in fold.Pliki)
            {
                plikiZnalezione.Add(p);
            }
            foreach (Folder f in fold.Podflodery)
            {
                szukajRek(f);
            }
        }

        private void szukajRekArch(Folder fold)
        {
            foreach (Plik p in fold.Pliki)
            {
                if (p.CzyArchiwum)
                {
                    try
                    {
                        PlikArchiwum pZip = (PlikArchiwum)p;
                        foreach (ArchiwumEntry ent in pZip.Pliki)
                        {
                            plikiWArchiwach.Add(ent);
                        }
                    }
                    catch
                    {

                    }
                   
                }
            }
            foreach (Folder f in fold.Podflodery)
            {
                szukajRek(f);
            }
        }

		#endregion Methods 
    }
}
